// page/component/cart/cart.js
const app = getApp();
const { request } = require('../../../utils/request');

Page({
  data: {
    carts: [],
    hasList: false,
    totalPrice: 0,
    selectAllStatus: true
  },

  // 生命周期函数--监听页面显示
  onShow: function () {
    this.refreshCartData();
  },

  // 重新请求购物车数据
  refreshCartData() {
    wx.showLoading({
      title: '加载中...',
    });
    request({
      url: '/cart',
      method: 'GET'
    })
    .then((res) => {
      wx.hideLoading();
      if (res.code === 2000) {
        const carts = res.data.map(item => ({
          id: item.id,
          title: item.product_name,
          num: item.quantity,
          seclected: item.selected && item.usable && item.stock >= item.quantity, // 初始化选中状态
          price: item.price,
          totalPrice: (item.price * item.quantity).toFixed(2),
          image: item.image_url,
          usable: item.usable,
          stock: item.stock
        }));
        this.setData({
          carts,
          hasList: carts.length > 0
        }, () => {
          this.calculateTotalPrice();
          this.updateSelectAllStatus();
        });
      } else {
        wx.showToast({
          title: '获取购物车数据失败',
          icon: 'none'
        });
        console.error('获取购物车数据失败:', res.message);
      }
    })
    .catch((error) => {
      wx.hideLoading();
      wx.showToast({
        title: '请求出错',
        icon: 'none'
      });
      console.error('请求购物车接口出错:', error);
    });
  },

  // 计算总价
  calculateTotalPrice() {
    let total = 0;
    this.data.carts.forEach(item => {
      if (item.seclected && item.usable && item.stock >= item.num) {
        total += item.num * item.price;
      }
    });
    this.setData({
      totalPrice: total.toFixed(2)
    });
  },

  // 更新全选状态
  updateSelectAllStatus() {
    const allSelected = this.data.carts.every(item => item.seclected);
    this.setData({
      selectAllStatus: allSelected
    });
  },

  // 当前商品选中事件
  selectList(e) {
    const index = e.currentTarget.dataset.index;
    const carts = this.data.carts;
    const cartItem = carts[index];
    if (!cartItem.usable || cartItem.stock < cartItem.num) {
      return; // 不可用或库存不足时不允许选中
    }
    carts[index].seclected = !carts[index].seclected;
    this.setData({
      carts
    }, () => {
      this.calculateTotalPrice();
      this.updateSelectAllStatus();
    });
  },

  // 购物车全选事件
  selectAll(e) {
    const selectAllStatus = !this.data.selectAllStatus;
    const carts = this.data.carts.map(item => ({
      ...item,
      seclected: selectAllStatus && item.usable && item.stock >= item.num
    }));
    this.setData({
      selectAllStatus,
      carts
    }, () => {
      this.calculateTotalPrice();
    });
  },

  // 绑定加数量事件
  addCount(e) {
    const index = e.currentTarget.dataset.index;
    const carts = this.data.carts;
    const cartItem = carts[index];

    // 不可用商品不允许编辑
    if (!cartItem.usable) {
      return; 
    }

    // 检查库存是否充足
    if (cartItem.stock <= cartItem.num) {
      wx.showToast({
        title: '库存不足',
        icon: 'none'
      });
      // 取消选中
      carts[index].seclected = false; 
      this.setData({
        carts
      }, () => {
        this.calculateTotalPrice();
        this.updateSelectAllStatus();
      });
      return;
    }

    const newQuantity = cartItem.num + 1;
    this.updateCartQuantity(cartItem.id, newQuantity, index);
  },

  // 绑定减数量事件
  minusCount(e) {
    const index = e.currentTarget.dataset.index;
    const carts = this.data.carts;
    const cartItem = carts[index];

    // 不可用商品不允许编辑
    if (!cartItem.usable) {
      return; 
    }

    // 数量不能小于 1
    if (cartItem.num <= 1) {
      return;
    }

    // 当库存小于数量且库存不为 0 时允许减操作
    if (cartItem.stock < cartItem.num && cartItem.stock > 0) {
      const newQuantity = cartItem.num - 1;
      this.updateCartQuantity(cartItem.id, newQuantity, index);
      return;
    }

    // 正常减操作
    const newQuantity = cartItem.num - 1;
    this.updateCartQuantity(cartItem.id, newQuantity, index);
  },

  // 调用接口更新购物车商品数量
  updateCartQuantity(id, quantity, index) {
    wx.showLoading({
      title: '更新中...',
    });
    request({
      url: '/cart/' + id,
      method: 'PUT',
      data: {
        id,
        quantity
      }
    })
    .then((res) => {
      if (res.code === 2000) {
        const carts = this.data.carts;
        carts[index].num = quantity;
        carts[index].totalPrice = (quantity * carts[index].price).toFixed(2);
        if (carts[index].stock < carts[index].num) {
          carts[index].seclected = false; // 库存不足时取消选中
          wx.showToast({
            title: '库存不足',
            icon: 'none'
          });
        }
        this.setData({
          carts
        }, () => {
          this.calculateTotalPrice();
          this.updateSelectAllStatus();
        });
      } else {
        wx.showToast({
          title: '更新失败',
          icon: 'none'
        });
        console.error('更新购物车商品数量失败:', res.message);
      }
    })
    .catch((error) => {
      wx.showToast({
        title: '请求出错',
        icon: 'none'
      });
      console.error('更新购物车商品数量请求出错:', error);
    })
    .finally(() => {
      // 在请求完成（成功或失败）时关闭加载提示
      wx.hideLoading(); 
    });
  },

  // 删除购物车当前商品
  deleteList(e) {
    const index = e.currentTarget.dataset.index;
    const cartItem = this.data.carts[index];
    wx.showModal({
      title: '提示',
      content: '确定要删除该商品吗？',
      success: (res) => {
        if (res.confirm) {
          this.deleteCartItem(cartItem.id);
        }
      }
    });
  },

  // 调用接口删除购物车商品
  deleteCartItem(id) {
    wx.showLoading({
      title: '删除中...',
    });
    request({
      url: '/cart/' + id,
      method: 'DELETE',
    })
    .then((res) => {
      wx.hideLoading();
      if (res.code === 2000) {
        this.refreshCartData();
      } else {
        wx.showToast({
          title: '删除失败',
          icon: 'none'
        });
        console.error('删除购物车商品失败:', res.message);
      }
    })
    .catch((error) => {
      wx.hideLoading();
      wx.showToast({
        title: '请求出错',
        icon: 'none'
      });
      console.error('删除购物车商品请求出错:', error);
    });
  },

  // 提交订单
  async submitOrder() {
    // 过滤出选中的商品
    const selectedItems = this.data.carts.filter(item => item.seclected);
    if (selectedItems.length === 0) {
      wx.showToast({
        title: '请选择要提交的商品',
        icon: 'none'
      });
      return;
    }

    const orderData = {
      // items: selectedItems.map(item => ({
      //   product_id: item.id,
      //   price: item.price,
      //   quantity: item.num // 这里使用 num 而不是 quantity
      // }))
      cart_ids: selectedItems.map(item => item.id)
    };

    request({
      url: '/order',
        method: 'POST',
        data: orderData,
        showLoading: true
    })
    .then((res) => {
      if (res) {
        wx.showToast({
          title: '订单提交成功',
          icon: 'success'
        });
        wx.navigateTo({
          url: '/page/component/orders/orders'
        });
      } else {
        console.error('订单提交失败');
      }
    })
    .finally(() => {
      // 在请求完成（成功或失败）时关闭加载提示
      wx.hideLoading(); 
    });

  },
  // 获取库存不足商品的库存
  getStockOfOverQuantityItem() {
    const carts = this.data.carts;
    for (let i = 0; i < carts.length; i++) {
      if (carts[i].num > carts[i].stock) {
        return carts[i].stock;
      }
    }
    return 0;
  },
});